'use server'

import db from '@/db/db'
import { contracts, contractItems } from '@/db/schema/contract'
import { eq } from 'drizzle-orm'

// 계약 생성 타입 정의
export interface CreateContractData {
  projectId: number
  vendorId: number
  contractName: string
  status?: string
}

// 계약 아이템 생성 타입 정의
export interface CreateContractItemData {
  contractId: number
  itemId: number
  description?: string
  quantity?: number
  unitPrice?: number
}

// 계약 생성
export async function createContract(data: CreateContractData) {
  try {
    // contractNo 생성 (간단한 방식으로 timestamp 기반)
    const contractNo = `TEST-${Date.now()}`
    
    const [newContract] = await db.insert(contracts).values({
      projectId: data.projectId,
      vendorId: data.vendorId,
      contractNo,
      contractName: data.contractName,
      status: data.status || 'TEST',
    }).returning({
      id: contracts.id,
      contractNo: contracts.contractNo,
      contractName: contracts.contractName,
      status: contracts.status,
    })
    
    return { 
      success: true, 
      data: newContract,
      message: '계약이 성공적으로 생성되었습니다.' 
    }
  } catch (error) {
    console.error('계약 생성 오류:', error)
    return { 
      success: false, 
      error: '계약을 생성할 수 없습니다.' 
    }
  }
}

// 계약 아이템 생성
export async function createContractItem(data: CreateContractItemData) {
  try {
    const [newContractItem] = await db.insert(contractItems).values({
      contractId: data.contractId,
      itemId: data.itemId,
      description: data.description,
      quantity: data.quantity || 1,
      unitPrice: data.unitPrice,
    }).returning({
      id: contractItems.id,
      contractId: contractItems.contractId,
      itemId: contractItems.itemId,
      quantity: contractItems.quantity,
    })
    
    return { 
      success: true, 
      data: newContractItem,
      message: '계약 아이템이 성공적으로 생성되었습니다.' 
    }
  } catch (error) {
    console.error('계약 아이템 생성 오류:', error)
    return { 
      success: false, 
      error: '계약 아이템을 생성할 수 없습니다.' 
    }
  }
}

// 여러 계약 아이템 일괄 생성
export async function createMultipleContractItems(contractId: number, itemsData: Omit<CreateContractItemData, 'contractId'>[]) {
  try {
    const itemsToInsert = itemsData.map(item => ({
      contractId,
      itemId: item.itemId,
      description: item.description,
      quantity: item.quantity || 1,
      unitPrice: item.unitPrice,
    }))
    
    const newContractItems = await db.insert(contractItems).values(itemsToInsert).returning({
      id: contractItems.id,
      contractId: contractItems.contractId,
      itemId: contractItems.itemId,
      quantity: contractItems.quantity,
    })
    
    return { 
      success: true, 
      data: newContractItems,
      message: `${newContractItems.length}개의 계약 아이템이 성공적으로 생성되었습니다.` 
    }
  } catch (error) {
    console.error('계약 아이템 일괄 생성 오류:', error)
    return { 
      success: false, 
      error: '계약 아이템을 일괄 생성할 수 없습니다.' 
    }
  }
}

// 계약 수정
export async function updateContract(contractId: number, data: Partial<CreateContractData>) {
  try {
    const [updatedContract] = await db.update(contracts)
      .set({
        projectId: data.projectId,
        vendorId: data.vendorId,
        contractName: data.contractName,
        status: data.status,
        updatedAt: new Date(),
      })
      .where(eq(contracts.id, contractId))
      .returning({
        id: contracts.id,
        contractNo: contracts.contractNo,
        contractName: contracts.contractName,
        status: contracts.status,
      })
    
    return { 
      success: true, 
      data: updatedContract,
      message: '계약이 성공적으로 수정되었습니다.' 
    }
  } catch (error) {
    console.error('계약 수정 오류:', error)
    return { 
      success: false, 
      error: '계약을 수정할 수 없습니다.' 
    }
  }
}

// 계약 아이템 수정
export async function updateContractItem(contractItemId: number, data: Partial<CreateContractItemData>) {
  try {
    const [updatedContractItem] = await db.update(contractItems)
      .set({
        description: data.description,
        quantity: data.quantity,
        unitPrice: data.unitPrice,
        updatedAt: new Date(),
      })
      .where(eq(contractItems.id, contractItemId))
      .returning({
        id: contractItems.id,
        contractId: contractItems.contractId,
        itemId: contractItems.itemId,
        quantity: contractItems.quantity,
      })
    
    return { 
      success: true, 
      data: updatedContractItem,
      message: '계약 아이템이 성공적으로 수정되었습니다.' 
    }
  } catch (error) {
    console.error('계약 아이템 수정 오류:', error)
    return { 
      success: false, 
      error: '계약 아이템을 수정할 수 없습니다.' 
    }
  }
}

// 계약 아이템 삭제
export async function deleteContractItem(contractItemId: number) {
  try {
    await db.delete(contractItems).where(eq(contractItems.id, contractItemId))
    
    return { 
      success: true, 
      message: '계약 아이템이 성공적으로 삭제되었습니다.' 
    }
  } catch (error) {
    console.error('계약 아이템 삭제 오류:', error)
    return { 
      success: false, 
      error: '계약 아이템을 삭제할 수 없습니다.' 
    }
  }
}